#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <malloc.h>
#include <stdlib.h>

#include "test_task.h"
#include "msg.h"
#include "log.h"
#include "mem.h"
#include "task.h"
#include "task_manager.h"

struct test_data {
	int value;
};

int msg_ops1(struct msg *msg)
{
	char from[128];
	strcpy(from, msg->from);
	
	strcpy(msg->from, "test1");
	strcpy(msg->to, from);
	msg->is_request = 0;

	struct test_data *test_data = (struct test_data *)(msg->data);
	test_data->value += 100;

	send_msg(msg);

	return 0;
}

int msg_ops2(struct msg *msg)
{
	char from[128];
	strcpy(from, msg->from);
	
	strcpy(msg->from, "test2");
	strcpy(msg->to, from);
	msg->is_request = 0;

	struct test_data *test_data = (struct test_data *)(msg->data);
	test_data->value += 10;

	send_msg(msg);

	return 0;
}

int msg_ops3(struct msg *msg)
{
	char from[128];
	strcpy(from, msg->from);
	
	strcpy(msg->from, "test3");
	strcpy(msg->to, from);
	msg->is_request = 0;

	struct test_data *test_data = (struct test_data *)(msg->data);
	test_data->value += 1000;

	send_msg(msg);

	return 0;
}

int msg_ops4(struct msg *msg)
{
	char from[128];
	strcpy(from, msg->from);
	
	strcpy(msg->from, "test4");
	strcpy(msg->to, from);
	msg->is_request = 0;

	struct test_data *test_data = (struct test_data *)(msg->data);
	test_data->value += 1000;

	send_msg(msg);

	return 0;
}

int msg_ops5(struct msg *msg)
{
	char from[128];
	strcpy(from, msg->from);
	
	strcpy(msg->from, "test5");
	strcpy(msg->to, from);
	msg->is_request = 0;

	struct test_data *test_data = (struct test_data *)(msg->data);
	test_data->value += 1000;

	send_msg(msg);

	return 0;
}

int msg_ops6(struct msg *msg)
{
	char from[128];
	strcpy(from, msg->from);
	
	strcpy(msg->from, "test6");
	strcpy(msg->to, from);
	msg->is_request = 0;

	struct test_data *test_data = (struct test_data *)(msg->data);
	test_data->value += 1000;

	send_msg(msg);

	return 0;
}

int msg_ops7(struct msg *msg)
{
	return 0;
}

int msg_ops8(struct msg *msg)
{
	return 0;
}

int msg_ops9(struct msg *msg)
{
	return 0;
}

void *test_func1(void *arg)
{
	int i = 0;
	while (1) {
		//printf("\nbegin test1 send and receive\n");
		//printf("A %d\n", i);	
		i++;

		struct msg *msg = (struct msg *)malloc(sizeof(struct msg));
		if (msg == NULL) {
			printf("No enough mem.\n");
			exit(-1);
		}
		strcpy(msg->from, "test1");	
		strcpy(msg->to, "test2");	
		msg->is_request = 1;

		struct test_data *test_data = (void *)malloc(sizeof(struct test_data));
		//check...
		test_data->value = 0;
		msg->data = (void *)test_data;

		//printf("value = %d\n",msg->is_request);
		int ret = 0;
		ret = send_msg(msg);
		if (ret != 0) {
			log_print("Cann't send msg");
		} else {
			ret = receive_msg(&msg);

			while (ret == -3) {
				ret = receive_msg(&msg);
				usleep(10);
			}

			if (ret != 0) {
				printf("cann't recevie msg. ret = %d\n", ret);
			}

		//	printf("value = %d\n",msg->is_request);
		}

		strcpy(msg->from, "test1");	
		strcpy(msg->to, "test3");	
		msg->is_request = 1;

		//printf("value = %d\n",msg->is_request);
		ret = send_msg(msg);
		if (ret != 0) {
			log_print("Cann't send msg");
		} else {
			ret = receive_msg(&msg);

			while (ret == -3) {
				ret = receive_msg(&msg);
				usleep(10);
			}

			if (ret != 0) {
				printf("cann't recevie msg. ret = %d\n", ret);
			}

		//	printf("value = %d\n",msg->is_request);
		}
		printf("test1's result: %d\n", ((struct test_data *)(msg->data))->value);

		free(msg->data);
		free(msg);
		//printf("\nend test1 send and receive\n");

		//sleep(1);
	}

	return ((void *)0);
}

void *test_func2(void *arg)
{
	int i = 0;
	while (1) {
		//printf("\nbegin test2 send and receive\n");
		//printf("A %d\n", i);	
		i++;

		struct msg *msg = (struct msg *)malloc(sizeof(struct msg));
		if (msg == NULL) {
			printf("No enough mem.\n");
			exit(-1);
		}
		strcpy(msg->from, "test2");	
		strcpy(msg->to, "test1");	
		msg->is_request = 1;

		struct test_data *test_data = (void *)malloc(sizeof(struct test_data));
		//check...
		test_data->value = 0;
		msg->data = (void *)test_data;

		//printf("value = %d\n",msg->is_request);
		int ret = 0;
		ret = send_msg(msg);
		if (ret != 0) {
			log_print("Cann't send msg");
		} else {
			ret = receive_msg(&msg);

			while (ret == -3) {
				ret = receive_msg(&msg);
				usleep(10);
			}

			if (ret != 0) {
				printf("cann't recevie msg. ret = %d\n", ret);
			}

		//	printf("value = %d\n",msg->is_request);
		}

		strcpy(msg->from, "test2");	
		strcpy(msg->to, "test3");	
		msg->is_request = 1;

		//printf("value = %d\n",msg->is_request);
		ret = send_msg(msg);
		if (ret != 0) {
			log_print("Cann't send msg");
		} else {
			ret = receive_msg(&msg);

			while (ret == -3) {
				ret = receive_msg(&msg);
				usleep(10);
			}

			if (ret != 0) {
				printf("cann't recevie msg. ret = %d\n", ret);
			}

		//	printf("value = %d\n",msg->is_request);
		}
		printf("test2's result: %d\n", ((struct test_data *)(msg->data))->value);

		free(msg->data);
		free(msg);
		//printf("\nend test2 send and receive\n");

	//	sleep(2);
	}

	return ((void *)0);
}

void *test_func3(void *arg)
{
	int i = 0;
	while (1) {
		//printf("\nbegin test3 send and receive\n");
		//printf("A %d\n", i);	
		i++;

		struct msg *msg = (struct msg *)malloc(sizeof(struct msg));
		if (msg == NULL) {
			printf("No enough mem.\n");
			exit(-1);
		}
		strcpy(msg->from, "test3");	
		strcpy(msg->to, "test1");	
		msg->is_request = 1;

		struct test_data *test_data = (void *)malloc(sizeof(struct test_data));
		//check...
		test_data->value = 0;
		msg->data = (void *)test_data;

		//printf("value = %d\n",msg->is_request);
		int ret = 0;
		ret = send_msg(msg);
		if (ret != 0) {
			log_print("Cann't send msg");
		} else {
			ret = receive_msg(&msg);

			while (ret == -3) {
				ret = receive_msg(&msg);
				usleep(10);
			}

			if (ret != 0) {
				printf("cann't recevie msg. ret = %d\n", ret);
			}

		//	printf("value = %d\n",msg->is_request);
		}

		strcpy(msg->from, "test3");	
		strcpy(msg->to, "test2");	
		msg->is_request = 1;

		//printf("value = %d\n",msg->is_request);
		ret = send_msg(msg);
		if (ret != 0) {
			log_print("Cann't send msg");
		} else {
			ret = receive_msg(&msg);

			while (ret == -3) {
				ret = receive_msg(&msg);
				usleep(10);
			}

			if (ret != 0) {
				printf("cann't recevie msg. ret = %d\n", ret);
			}

		//	printf("value = %d\n",msg->is_request);
		}
		printf("test3's result: %d\n", ((struct test_data *)(msg->data))->value);

		free(msg->data);
		free(msg);
	//	printf("\nend test3 send and receive\n");

	//	sleep(4);
	}

	return ((void *)0);
}

void *test_func4(void *arg)
{
	int i = 0;
	while (1) {
		//printf("\nbegin test3 send and receive\n");
		//printf("A %d\n", i);	
		i++;

		struct msg *msg = (struct msg *)malloc(sizeof(struct msg));
		if (msg == NULL) {
			printf("No enough mem.\n");
			exit(-1);
		}
		strcpy(msg->from, "test4");	
		strcpy(msg->to, "test1");	
		msg->is_request = 1;

		struct test_data *test_data = (void *)malloc(sizeof(struct test_data));
		//check...
		test_data->value = 0;
		msg->data = (void *)test_data;

		//printf("value = %d\n",msg->is_request);
		int ret = 0;
		ret = send_msg(msg);
		if (ret != 0) {
			log_print("Cann't send msg");
		} else {
			ret = receive_msg(&msg);

			while (ret == -3) {
				ret = receive_msg(&msg);
				usleep(10);
			}

			if (ret != 0) {
				printf("cann't recevie msg. ret = %d\n", ret);
			}

		//	printf("value = %d\n",msg->is_request);
		}

		strcpy(msg->from, "test4");	
		strcpy(msg->to, "test2");	
		msg->is_request = 1;

		//printf("value = %d\n",msg->is_request);
		ret = send_msg(msg);
		if (ret != 0) {
			log_print("Cann't send msg");
		} else {
			ret = receive_msg(&msg);

			while (ret == -3) {
				ret = receive_msg(&msg);
				usleep(10);
			}

			if (ret != 0) {
				printf("cann't recevie msg. ret = %d\n", ret);
			}

		//	printf("value = %d\n",msg->is_request);
		}
		printf("test4's result: %d\n", ((struct test_data *)(msg->data))->value);

		free(msg->data);
		free(msg);
	//	printf("\nend test3 send and receive\n");

	//	sleep(4);
	}

	return ((void *)0);
}

void *test_func5(void *arg)
{
	int i = 0;
	while (1) {
		//printf("\nbegin test3 send and receive\n");
		//printf("A %d\n", i);	
		i++;

		struct msg *msg = (struct msg *)malloc(sizeof(struct msg));
		if (msg == NULL) {
			printf("No enough mem.\n");
			exit(-1);
		}
		strcpy(msg->from, "test5");	
		strcpy(msg->to, "test1");	
		msg->is_request = 1;

		struct test_data *test_data = (void *)malloc(sizeof(struct test_data));
		//check...
		test_data->value = 0;
		msg->data = (void *)test_data;

		//printf("value = %d\n",msg->is_request);
		int ret = 0;
		ret = send_msg(msg);
		if (ret != 0) {
			log_print("Cann't send msg");
		} else {
			ret = receive_msg(&msg);

			while (ret == -3) {
				ret = receive_msg(&msg);
				usleep(10);
			}

			if (ret != 0) {
				printf("cann't recevie msg. ret = %d\n", ret);
			}

		//	printf("value = %d\n",msg->is_request);
		}

		strcpy(msg->from, "test5");	
		strcpy(msg->to, "test2");	
		msg->is_request = 1;

		//printf("value = %d\n",msg->is_request);
		ret = send_msg(msg);
		if (ret != 0) {
			log_print("Cann't send msg");
		} else {
			ret = receive_msg(&msg);

			while (ret == -3) {
				ret = receive_msg(&msg);
				usleep(10);
			}

			if (ret != 0) {
				printf("cann't recevie msg. ret = %d\n", ret);
			}

		//	printf("value = %d\n",msg->is_request);
		}
		printf("test5's result: %d\n", ((struct test_data *)(msg->data))->value);

		free(msg->data);
		free(msg);
	//	printf("\nend test3 send and receive\n");

	//	sleep(4);
	}

	return ((void *)0);
}

void *test_func6(void *arg)
{
	int i = 0;
	while (1) {
		//printf("\nbegin test3 send and receive\n");
		//printf("A %d\n", i);	
		i++;

		struct msg *msg = (struct msg *)malloc(sizeof(struct msg));
		if (msg == NULL) {
			printf("No enough mem.\n");
			exit(-1);
		}
		strcpy(msg->from, "test6");	
		strcpy(msg->to, "test1");	
		msg->is_request = 1;

		struct test_data *test_data = (void *)malloc(sizeof(struct test_data));
		//check...
		test_data->value = 0;
		msg->data = (void *)test_data;

		//printf("value = %d\n",msg->is_request);
		int ret = 0;
		ret = send_msg(msg);
		if (ret != 0) {
			log_print("Cann't send msg");
		} else {
			ret = receive_msg(&msg);

			while (ret == -3) {
				ret = receive_msg(&msg);
				usleep(10);
			}

			if (ret != 0) {
				printf("cann't recevie msg. ret = %d\n", ret);
			}

		//	printf("value = %d\n",msg->is_request);
		}

		strcpy(msg->from, "test6");	
		strcpy(msg->to, "test2");	
		msg->is_request = 1;

		//printf("value = %d\n",msg->is_request);
		ret = send_msg(msg);
		if (ret != 0) {
			log_print("Cann't send msg");
		} else {
			ret = receive_msg(&msg);

			while (ret == -3) {
				ret = receive_msg(&msg);
				usleep(10);
			}

			if (ret != 0) {
				printf("cann't recevie msg. ret = %d\n", ret);
			}

		//	printf("value = %d\n",msg->is_request);
		}
		printf("test6's result: %d\n", ((struct test_data *)(msg->data))->value);

		free(msg->data);
		free(msg);
	//	printf("\nend test3 send and receive\n");

	//	sleep(4);
	}

	return ((void *)0);
}

struct test_s {
	struct test_s *next;
	int a[1000];
	int b[1000];
	int c[1000];
};

void *test_func7(void *arg)
{
	struct task *task = NULL;
	pthread_t tid = pthread_self();
	task = get_task_by_tid(tid);

	while (1) {
	//	printf("begin s_malloc------\n");
	//	printf("mem->total: %ld\n", task->mm->total);
		struct test_s *test_s1 = (struct test_s *)s_malloc(sizeof(struct test_s));	
	//	printf("mem->total: %ld\n", task->mm->total);
		struct test_s *test_s2 = (struct test_s *)s_malloc(sizeof(struct test_s));	
	//	printf("mem->total: %ld\n", task->mm->total);
		struct test_s *test_s3 = (struct test_s *)s_malloc(sizeof(struct test_s));	
	//	printf("mem->total: %ld\n", task->mm->total);
		struct test_s *test_s4 = (struct test_s *)s_malloc(sizeof(struct test_s));	
	//	printf("mem->total: %ld\n", task->mm->total);
		struct test_s *test_s5 = (struct test_s *)s_malloc(sizeof(struct test_s));	
	//	printf("mem->total: %ld\n", task->mm->total);
	//	printf("end s_malloc------\n\n");

		test_s1->next = test_s2;
		test_s2->next = test_s3;
		test_s3->next = test_s4;
		test_s4->next = test_s5;
		test_s5->next = test_s1;
		test_s1->a[0] = 1080;
		test_s2->a[0] = 1007;
		test_s3->a[0] = 1070;
		test_s4->a[0] = 1900;
		test_s5->a[0] = 8100;

#if 1
	//	printf("begin s_free------\n");
	//	printf("mem->total: %ld\n", task->mm->total);
		s_free(test_s1);
	//	printf("mem->total: %ld\n", task->mm->total);
		s_free(test_s2);
	//	printf("mem->total: %ld\n", task->mm->total);
		s_free(test_s3);
	//	printf("mem->total: %ld\n", task->mm->total);
		s_free(test_s4);
	//	printf("mem->total: %ld\n", task->mm->total);
		s_free(test_s5);
	//	printf("mem->total: %ld\n", task->mm->total);
	//	printf("end s_free------\n\n");
#endif
		//sleep(1);
	}
	return NULL;
}

void *test_func8(void *arg)
{
#if 0
	struct task *task = NULL;
	pthread_t tid = pthread_self();
	task = get_task_by_tid(tid);

	int i = 1;
	while (i < 100) {
		void *p = s_malloc(i);
		if (i % 2 == 0)
		{
			s_free(p);
		}
		i++;
		if (i == 100) {
			i = 1;
		}
		printf("================== test 8 mem->total: %ld\n", task->mm->total);
	}
#endif
	return NULL;
}

void *test_func9(void *arg)
{
	struct task *task = NULL;
	pthread_t tid = pthread_self();
	task = get_task_by_tid(tid);

	while (1) {
	//	printf("begin s_malloc------\n");
	//	printf("mem->total: %ld\n", task->mm->total);
		struct test_s *test_s1 = (struct test_s *)s_malloc(sizeof(struct test_s));	
	//	printf("mem->total: %ld\n", task->mm->total);
		struct test_s *test_s2 = (struct test_s *)s_malloc(sizeof(struct test_s));	
	//	printf("mem->total: %ld\n", task->mm->total);
		struct test_s *test_s3 = (struct test_s *)s_malloc(sizeof(struct test_s));	
	//	printf("mem->total: %ld\n", task->mm->total);
		struct test_s *test_s4 = (struct test_s *)s_malloc(sizeof(struct test_s));	
	//	printf("mem->total: %ld\n", task->mm->total);
		struct test_s *test_s5 = (struct test_s *)s_malloc(sizeof(struct test_s));	
	//	printf("mem->total: %ld\n", task->mm->total);
	//	printf("end s_malloc------\n\n");

		test_s1->next = test_s2;
		test_s2->next = test_s3;
		test_s3->next = test_s4;
		test_s4->next = test_s5;
		test_s5->next = test_s1;
		test_s1->a[0] = 1080;
		test_s2->a[0] = 1007;
		test_s3->a[0] = 1070;
		test_s4->a[0] = 1900;
		test_s5->a[0] = 8100;

#if 1
	//	printf("begin s_free------\n");
	//	printf("mem->total: %ld\n", task->mm->total);
		s_free(test_s1);
	//	printf("mem->total: %ld\n", task->mm->total);
		s_free(test_s2);
	//	printf("mem->total: %ld\n", task->mm->total);
		s_free(test_s3);
	//	printf("mem->total: %ld\n", task->mm->total);
		s_free(test_s4);
	//	printf("mem->total: %ld\n", task->mm->total);
		s_free(test_s5);
	//	printf("mem->total: %ld\n", task->mm->total);
	//	printf("end s_free------\n\n");
#endif
		//sleep(1);
	}
	return NULL;
}

